home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 October: Mac OS SDK / Dev.CD Oct 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / CIncludes / OCEMessaging.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-12  |  31.0 KB  |  1,111 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        OCEMessaging.h
  3.  
  4.      Contains:    Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Release:    Universal Interfaces 3.0.1
  8.  
  9.      Copyright:    © 1994-1997 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. */
  18. #ifndef __OCEMESSAGING__
  19. #define __OCEMESSAGING__
  20.  
  21. #ifndef __FILES__
  22. #include <Files.h>
  23. #endif
  24. #ifndef __TYPES__
  25. #include <Types.h>
  26. #endif
  27.  
  28. #ifndef __DIGITALSIGNATURE__
  29. #include <DigitalSignature.h>
  30. #endif
  31. #ifndef __OCE__
  32. #include <OCE.h>
  33. #endif
  34. #ifndef __OCEAUTHDIR__
  35. #include <OCEAuthDir.h>
  36. #endif
  37.  
  38.  
  39.  
  40. #if PRAGMA_ONCE
  41. #pragma once
  42. #endif
  43.  
  44. #ifdef __cplusplus
  45. extern "C" {
  46. #endif
  47.  
  48. #if PRAGMA_IMPORT
  49. #pragma import on
  50. #endif
  51.  
  52. #if PRAGMA_STRUCT_ALIGN
  53.     #pragma options align=mac68k
  54. #elif PRAGMA_STRUCT_PACKPUSH
  55.     #pragma pack(push, 2)
  56. #elif PRAGMA_STRUCT_PACK
  57.     #pragma pack(2)
  58. #endif
  59.  
  60. /******************************************************************************/
  61. /* Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  62. message ids and priorities, etc. */
  63.  
  64. /* Values of IPMPriority */
  65.  
  66. enum {
  67.     kIPMAnyPriority                = 0,                            /* FOR FILTER ONLY */
  68.     kIPMNormalPriority            = 1,
  69.     kIPMLowPriority                = 2,
  70.     kIPMHighPriority            = 3
  71. };
  72.  
  73. typedef Byte                             IPMPriority;
  74. /* Values of IPMAccessMode */
  75.  
  76. enum {
  77.     kIPMAtMark                    = 0,
  78.     kIPMFromStart                = 1,
  79.     kIPMFromLEOM                = 2,
  80.     kIPMFromMark                = 3
  81. };
  82.  
  83. typedef unsigned short                     IPMAccessMode;
  84.  
  85. enum {
  86.     kIPMUpdateMsgBit            = 4,
  87.     kIPMNewMsgBit                = 5,
  88.     kIPMDeleteMsgBit            = 6
  89. };
  90.  
  91. /* Values of IPMNotificationType */
  92.  
  93. enum {
  94.     kIPMUpdateMsgMask            = 1 << kIPMUpdateMsgBit,
  95.     kIPMNewMsgMask                = 1 << kIPMNewMsgBit,
  96.     kIPMDeleteMsgMask            = 1 << kIPMDeleteMsgBit
  97. };
  98.  
  99. typedef Byte                             IPMNotificationType;
  100. /* Values of IPMSenderTag */
  101.  
  102. enum {
  103.     kIPMSenderRStringTag        = 0,
  104.     kIPMSenderRecordIDTag        = 1
  105. };
  106.  
  107. typedef unsigned short                     IPMSenderTag;
  108.  
  109. enum {
  110.     kIPMFromDistListBit            = 0,
  111.     kIPMDummyRecBit                = 1,
  112.     kIPMFeedbackRecBit            = 2,                            /* should be redirected to feedback queue */
  113.     kIPMReporterRecBit            = 3,                            /* should be redirected to reporter original queue */
  114.     kIPMBCCRecBit                = 4                                /* this recipient is blind to all recipients of message */
  115. };
  116.  
  117. /* Values of OCERecipientOffsetFlags */
  118.  
  119. enum {
  120.     kIPMFromDistListMask        = 1 << kIPMFromDistListBit,
  121.     kIPMDummyRecMask            = 1 << kIPMDummyRecBit,
  122.     kIPMFeedbackRecMask            = 1 << kIPMFeedbackRecBit,
  123.     kIPMReporterRecMask            = 1 << kIPMReporterRecBit,
  124.     kIPMBCCRecMask                = 1 << kIPMBCCRecBit
  125. };
  126.  
  127. typedef Byte                             OCERecipientOffsetFlags;
  128. struct OCECreatorType {
  129.     OSType                             msgCreator;
  130.     OSType                             msgType;
  131. };
  132. typedef struct OCECreatorType OCECreatorType;
  133.  
  134.  
  135. enum {
  136.     kIPMTypeWildCard            = FOUR_CHAR_CODE('ipmw'),
  137.     kIPMFamilyUnspecified        = 0,
  138.     kIPMFamilyWildCard            = 0x3F3F3F3F,                    /* '????' * well known signature */
  139.     kIPMSignature                = FOUR_CHAR_CODE('ipms'),        /* base type * well known message types */
  140.     kIPMReportNotify            = FOUR_CHAR_CODE('rptn'),        /* routing feedback * well known message block types */
  141.     kIPMEnclosedMsgType            = FOUR_CHAR_CODE('emsg'),        /* enclosed (nested) message */
  142.     kIPMReportInfo                = FOUR_CHAR_CODE('rpti'),        /* recipient information */
  143.     kIPMDigitalSignature        = FOUR_CHAR_CODE('dsig')        /* digital signature */
  144. };
  145.  
  146. /* Values of IPMMsgFormat */
  147.  
  148. enum {
  149.     kIPMOSFormatType            = 1,
  150.     kIPMStringFormatType        = 2
  151. };
  152.  
  153. typedef unsigned short                     IPMMsgFormat;
  154. typedef Str32                             IPMStringMsgType;
  155. union TheType {
  156.     OCECreatorType                     msgOSType;
  157.     IPMStringMsgType                 msgStrType;
  158. };
  159. typedef union TheType TheType;
  160.  
  161. struct IPMMsgType {
  162.     IPMMsgFormat                     format;                        /* IPMMsgFormat*/
  163.     TheType                         theType;
  164. };
  165. typedef struct IPMMsgType IPMMsgType;
  166.  
  167. /*
  168. Following are the known extension values for IPM addresses handled by Apple.
  169. We define the definition of the entn extension below.
  170. */
  171.  
  172. enum {
  173.     kOCEalanXtn                    = FOUR_CHAR_CODE('alan'),
  174.     kOCEentnXtn                    = FOUR_CHAR_CODE('entn'),        /* entn = entity name (aka DSSpec) */
  175.     kOCEaphnXtn                    = FOUR_CHAR_CODE('aphn')
  176. };
  177.  
  178. /*
  179. Following are the specific definitions for the extension for the standard
  180. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  181. IPMEntityNameExtension.]
  182. */
  183. /* entn extension forms */
  184.  
  185. enum {
  186.     kOCEAddrXtn                    = FOUR_CHAR_CODE('addr'),
  187.     kOCEQnamXtn                    = FOUR_CHAR_CODE('qnam'),
  188.     kOCEAttrXtn                    = FOUR_CHAR_CODE('attr'),        /* an attribute specification */
  189.     kOCESpAtXtn                    = FOUR_CHAR_CODE('spat')        /* specific attribute */
  190. };
  191.  
  192. /*
  193. Following are the specific definitions for standard
  194. OCEMail 'aphn' extension value.  
  195.  
  196. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  197. if length odd, then a pad byte (zero) should be introduced before the next field).
  198.  
  199. The extension value is in the packed form of the following structure:
  200.     RString        phoneNumber;
  201.     RString        modemType;
  202.     Str32        queueuName;
  203.  
  204. The body of phoneNumber compound RString is in the packed form of the following structure:
  205.     short         subType;
  206.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  207.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  208.     RString        phone;                        // used when subType == kOCEUseHandyDial
  209.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  210.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  211. */
  212. /* phoneNumber sub type constants */
  213.  
  214. enum {
  215.     kOCEUseHandyDial            = 1,
  216.     kOCEDontUseHandyDial        = 2
  217. };
  218.  
  219. /* FORMAT OF A PACKED FORM RECIPIENT */
  220. struct ProtoOCEPackedRecipient {
  221.     unsigned short                     dataLength;
  222. };
  223. typedef struct ProtoOCEPackedRecipient ProtoOCEPackedRecipient;
  224.  
  225.  
  226. enum {
  227.     kOCEPackedRecipientMaxBytes    = (4096 - sizeof(ProtoOCEPackedRecipient))
  228. };
  229.  
  230. struct OCEPackedRecipient {
  231.     unsigned short                     dataLength;
  232.     Byte                             data[4094];
  233. };
  234. typedef struct OCEPackedRecipient OCEPackedRecipient;
  235.  
  236. struct IPMEntnQueueExtension {
  237.     Str32                             queueName;
  238. };
  239. typedef struct IPMEntnQueueExtension IPMEntnQueueExtension;
  240.  
  241. /* kOCEAttrXtn */
  242. struct IPMEntnAttributeExtension {
  243.     AttributeType                     attributeName;
  244. };
  245. typedef struct IPMEntnAttributeExtension IPMEntnAttributeExtension;
  246.  
  247. /* kOCESpAtXtn */
  248. struct IPMEntnSpecificAttributeExtension {
  249.     AttributeCreationID             attributeCreationID;
  250.     AttributeType                     attributeName;
  251. };
  252. typedef struct IPMEntnSpecificAttributeExtension IPMEntnSpecificAttributeExtension;
  253.  
  254. /* All IPM entn extensions fit within the following */
  255. struct IPMEntityNameExtension {
  256.     OSType                             subExtensionType;
  257.     union {
  258.         IPMEntnSpecificAttributeExtension  specificAttribute;
  259.         IPMEntnAttributeExtension         attribute;
  260.         IPMEntnQueueExtension             queue;
  261.     }                                 u;
  262. };
  263. typedef struct IPMEntityNameExtension IPMEntityNameExtension;
  264.  
  265. /* addresses with kIPMNBPXtn should specify this nbp type */
  266. #define kIPMWSReceiverNBPType "\pMsgReceiver" 
  267. struct IPMMsgID {
  268.     unsigned long                     id[4];
  269. };
  270. typedef struct IPMMsgID IPMMsgID;
  271.  
  272.  
  273. /* Values of IPMHeaderSelector */
  274.  
  275. enum {
  276.     kIPMTOC                        = 0,
  277.     kIPMSender                    = 1,
  278.     kIPMProcessHint                = 2,
  279.     kIPMMessageTitle            = 3,
  280.     kIPMMessageType                = 4,
  281.     kIPMFixedInfo                = 7
  282. };
  283.  
  284. typedef Byte                             IPMHeaderSelector;
  285. union TheSender {
  286.     RString                         rString;
  287.     PackedRecordID                     rid;
  288. };
  289. typedef union TheSender TheSender;
  290.  
  291. struct IPMSender {
  292.     IPMSenderTag                     sendTag;
  293.     TheSender                         theSender;
  294. };
  295. typedef struct IPMSender IPMSender;
  296.  
  297. /******************************************************************************/
  298. /* Definitions specific to OCEMessaging */
  299. typedef unsigned long                     IPMContextRef;
  300. typedef unsigned long                     IPMQueueRef;
  301. typedef unsigned long                     IPMMsgRef;
  302. typedef unsigned long                     IPMSeqNum;
  303. typedef Str32                             IPMProcHint;
  304. typedef Str32                             IPMQueueName;
  305. typedef CALLBACK_API( void , IPMNoteProcPtr )(IPMQueueRef queue, IPMSeqNum seqNum, IPMNotificationType notificationType, unsigned long userData);
  306. typedef STACK_UPP_TYPE(IPMNoteProcPtr)                             IPMNoteUPP;
  307. enum { uppIPMNoteProcInfo = 0x000037C0 };                         /* pascal no_return_value Func(4_bytes, 4_bytes, 1_byte, 4_bytes) */
  308. #define NewIPMNoteProc(userRoutine)                             (IPMNoteUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPMNoteProcInfo, GetCurrentArchitecture())
  309. #define CallIPMNoteProc(userRoutine, queue, seqNum, notificationType, userData)  CALL_FOUR_PARAMETER_UPP((userRoutine), uppIPMNoteProcInfo, (queue), (seqNum), (notificationType), (userData))
  310. struct IPMFixedHdrInfo {
  311.     unsigned short                     version;
  312.     Boolean                         authenticated;
  313.     Boolean                         signatureEnclosed;            /*  digital signature enclosed */
  314.     unsigned long                     msgSize;
  315.     IPMNotificationType             notification;
  316.     IPMPriority                     priority;
  317.     unsigned short                     blockCount;
  318.     unsigned short                     originalRcptCount;            /*        original number of recipients */
  319.     unsigned long                     refCon;                        /*        Client defined data */
  320.     unsigned short                     reserved;
  321.     UTCTime                         creationTime;                /*        Time when it was created */
  322.     IPMMsgID                         msgID;
  323.     OSType                             family;                        /* family this msg belongs (e.g. mail) */
  324. };
  325. typedef struct IPMFixedHdrInfo IPMFixedHdrInfo;
  326.  
  327.  
  328. enum {
  329.     kIPMDeliveryNotificationBit    = 0,
  330.     kIPMNonDeliveryNotificationBit = 1,
  331.     kIPMEncloseOriginalBit        = 2,
  332.     kIPMSummaryReportBit        = 3,                            /* modify enclose original to only on error */
  333.     kIPMOriginalOnlyOnErrorBit    = 4
  334. };
  335.  
  336.  
  337. enum {
  338.     kIPMNoNotificationMask        = 0x00,
  339.     kIPMDeliveryNotificationMask = 1 << kIPMDeliveryNotificationBit,
  340.     kIPMNonDeliveryNotificationMask = 1 << kIPMNonDeliveryNotificationBit,
  341.     kIPMDontEncloseOriginalMask    = 0x00,
  342.     kIPMEncloseOriginalMask        = 1 << kIPMEncloseOriginalBit,
  343.     kIPMImmediateReportMask        = 0x00,
  344.     kIPMSummaryReportMask        = 1 << kIPMSummaryReportBit,
  345.     kIPMOriginalOnlyOnErrorMask    = 1 << kIPMOriginalOnlyOnErrorBit,
  346.     kIPMEncloseOriginalOnErrorMask = (kIPMOriginalOnlyOnErrorMask | kIPMEncloseOriginalMask)
  347. };
  348.  
  349. /* standard Non delivery codes */
  350.  
  351. enum {
  352.     kIPMNoSuchRecipient            = 0x0001,
  353.     kIPMRecipientMalformed        = 0x0002,
  354.     kIPMRecipientAmbiguous        = 0x0003,
  355.     kIPMRecipientAccessDenied    = 0x0004,
  356.     kIPMGroupExpansionProblem    = 0x0005,
  357.     kIPMMsgUnreadable            = 0x0006,
  358.     kIPMMsgExpired                = 0x0007,
  359.     kIPMMsgNoTranslatableContent = 0x0008,
  360.     kIPMRecipientReqStdCont        = 0x0009,
  361.     kIPMRecipientReqSnapShot    = 0x000A,
  362.     kIPMNoTransferDiskFull        = 0x000B,
  363.     kIPMNoTransferMsgRejectedbyDest = 0x000C,
  364.     kIPMNoTransferMsgTooLarge    = 0x000D
  365. };
  366.  
  367. /*************************************************************************/
  368. /*
  369. This is the structure that will be returned by enumerate and getmsginfo
  370. This definition is just to give you a template, the position of msgType
  371. is variable since this is a packed structure.  procHint and msgType are
  372. packed and even length padded.
  373.  
  374. * master message info */
  375. struct IPMMsgInfo {
  376.     IPMSeqNum                         sequenceNum;
  377.     unsigned long                     userData;
  378.     unsigned short                     respIndex;
  379.     SInt8                             padByte;
  380.     IPMPriority                     priority;
  381.     unsigned long                     msgSize;
  382.     unsigned short                     originalRcptCount;
  383.     unsigned short                     reserved;
  384.     UTCTime                         creationTime;
  385.     IPMMsgID                         msgID;
  386.     OSType                             family;                        /* family this msg belongs (e.g. mail) */
  387.     IPMProcHint                     procHint;
  388.     SInt8                             filler2;
  389.     IPMMsgType                         msgType;
  390. };
  391. typedef struct IPMMsgInfo IPMMsgInfo;
  392.  
  393. typedef OCECreatorType                     IPMBlockType;
  394. struct IPMTOC {
  395.     IPMBlockType                     blockType;
  396.     long                             blockOffset;
  397.     unsigned long                     blockSize;
  398.     unsigned long                     blockRefCon;
  399. };
  400. typedef struct IPMTOC IPMTOC;
  401.  
  402. /*
  403. The following structure is just to describe the layout of the SingleFilter.
  404. Each field should be packed and word aligned when passed to the IPM ToolBox.
  405. */
  406. struct IPMSingleFilter {
  407.     IPMPriority                     priority;
  408.     SInt8                             padByte;
  409.     OSType                             family;                        /* family this msg belongs (e.g. mail), '????' for all */
  410.     ScriptCode                         script;                        /* Language Identifier */
  411.     IPMProcHint                     hint;
  412.     SInt8                             filler2;
  413.     IPMMsgType                         msgType;
  414. };
  415. typedef struct IPMSingleFilter IPMSingleFilter;
  416.  
  417. struct IPMFilter {
  418.     unsigned short                     count;
  419.     IPMSingleFilter                 sFilters[1];
  420. };
  421. typedef struct IPMFilter IPMFilter;
  422.  
  423. /*************************************************************************
  424. Following structures define the “start” of a recipient report block and the
  425. elements of the array respectively.
  426. */
  427. struct IPMReportBlockHeader {
  428.     IPMMsgID                         msgID;                        /* message id of the original */
  429.     UTCTime                         creationTime;                /* creation time of the report */
  430. };
  431. typedef struct IPMReportBlockHeader IPMReportBlockHeader;
  432.  
  433. struct OCERecipientReport {
  434.     unsigned short                     rcptIndex;                    /* index of recipient in original message */
  435.     OSErr                             result;                        /* result of sending letter to this recipient*/
  436. };
  437. typedef struct OCERecipientReport OCERecipientReport;
  438.  
  439. /*************************************************************************/
  440. typedef union IPMParamBlock             IPMParamBlock;
  441. typedef IPMParamBlock *                    IPMParamBlockPtr;
  442. typedef CALLBACK_API( void , IPMIOCompletionProcPtr )(IPMParamBlockPtr paramBlock);
  443. /*
  444.     WARNING: IPMIOCompletionProcPtr uses register based parameters under classic 68k
  445.              and cannot be written in a high-level language without 
  446.              the help of mixed mode or assembly glue.
  447. */
  448. typedef REGISTER_UPP_TYPE(IPMIOCompletionProcPtr)                 IPMIOCompletionUPP;
  449. struct IPMOpenContextPB {
  450.     void *                            qLink;
  451.     long                             reservedH1;
  452.     long                             reservedH2;
  453.     IPMIOCompletionUPP                 ioCompletion;
  454.     OSErr                             ioResult;
  455.     long                             saveA5;
  456.     short                             reqCode;
  457.     IPMContextRef                     contextRef;                    /* <--  Context reference to be used in further calls*/
  458. };
  459. typedef struct IPMOpenContextPB IPMOpenContextPB;
  460.  
  461. typedef IPMOpenContextPB                 IPMCloseContextPB;
  462. struct IPMCreateQueuePB {
  463.     void *                            qLink;
  464.     long                             reservedH1;
  465.     long                             reservedH2;
  466.     IPMIOCompletionUPP                 ioCompletion;
  467.     OSErr                             ioResult;
  468.     long                             saveA5;
  469.     short                             reqCode;
  470.     long                             filler1;
  471.     OCERecipient *                    queue;
  472.     AuthIdentity                     identity;                    /* used only if queue is remote */
  473.     PackedRecordID *                owner;                        /* used only if queue is remote */
  474. };
  475. typedef struct IPMCreateQueuePB IPMCreateQueuePB;
  476.  
  477. /* For createqueue and deletequeue only queue and identity are used */
  478. typedef IPMCreateQueuePB                 IPMDeleteQueuePB;
  479. struct IPMOpenQueuePB {
  480.     void *                            qLink;
  481.     long                             reservedH1;
  482.     long                             reservedH2;
  483.     IPMIOCompletionUPP                 ioCompletion;
  484.     OSErr                             ioResult;
  485.     long                             saveA5;
  486.     short                             reqCode;
  487.     IPMContextRef                     contextRef;
  488.     OCERecipient *                    queue;
  489.     AuthIdentity                     identity;
  490.     IPMFilter *                        filter;
  491.     IPMQueueRef                     newQueueRef;
  492.     IPMNoteUPP                         notificationProc;
  493.     unsigned long                     userData;
  494.     IPMNotificationType             noteType;
  495.     Byte                             padByte;
  496.     long                             reserved;
  497.     long                             reserved2;
  498. };
  499. typedef struct IPMOpenQueuePB IPMOpenQueuePB;
  500.  
  501. struct IPMCloseQueuePB {
  502.     void *                            qLink;
  503.     long                             reservedH1;
  504.     long                             reservedH2;
  505.     IPMIOCompletionUPP                 ioCompletion;
  506.     OSErr                             ioResult;
  507.     long                             saveA5;
  508.     short                             reqCode;
  509.     IPMQueueRef                     queueRef;
  510. };
  511. typedef struct IPMCloseQueuePB IPMCloseQueuePB;
  512.  
  513. struct IPMEnumerateQueuePB {
  514.     void *                            qLink;
  515.     long                             reservedH1;
  516.     long                             reservedH2;
  517.     IPMIOCompletionUPP                 ioCompletion;
  518.     OSErr                             ioResult;
  519.     long                             saveA5;
  520.     short                             reqCode;
  521.     IPMQueueRef                     queueRef;
  522.     IPMSeqNum                         startSeqNum;
  523.     Boolean                         getProcHint;
  524.     Boolean                         getMsgType;
  525.     short                             filler;
  526.     IPMFilter *                        filter;
  527.     unsigned short                     numToGet;
  528.     unsigned short                     numGotten;
  529.     unsigned long                     enumCount;
  530.     void *                            enumBuffer;                    /* will be packed array of IPMMsgInfo */
  531.     unsigned long                     actEnumCount;
  532. };
  533. typedef struct IPMEnumerateQueuePB IPMEnumerateQueuePB;
  534.  
  535. typedef IPMEnumerateQueuePB             IPMChangeQueueFilterPB;
  536. struct IPMDeleteMsgRangePB {
  537.     void *                            qLink;
  538.     long                             reservedH1;
  539.     long                             reservedH2;
  540.     IPMIOCompletionUPP                 ioCompletion;
  541.     OSErr                             ioResult;
  542.     long                             saveA5;
  543.     short                             reqCode;
  544.     IPMQueueRef                     queueRef;
  545.     IPMSeqNum                         startSeqNum;
  546.     IPMSeqNum                         endSeqNum;
  547.     IPMSeqNum                         lastSeqNum;
  548. };
  549. typedef struct IPMDeleteMsgRangePB IPMDeleteMsgRangePB;
  550.  
  551.  
  552. struct IPMOpenMsgPB {
  553.     void *                            qLink;
  554.     long                             reservedH1;
  555.     long                             reservedH2;
  556.     IPMIOCompletionUPP                 ioCompletion;
  557.     OSErr                             ioResult;
  558.     long                             saveA5;
  559.     short                             reqCode;
  560.     IPMQueueRef                     queueRef;
  561.     IPMSeqNum                         sequenceNum;
  562.     IPMMsgRef                         newMsgRef;
  563.     IPMSeqNum                         actualSeqNum;
  564.     Boolean                         exactMatch;
  565.     Byte                             padByte;
  566.     long                             reserved;
  567. };
  568. typedef struct IPMOpenMsgPB IPMOpenMsgPB;
  569.  
  570.  
  571. struct IPMOpenHFSMsgPB {
  572.     void *                            qLink;
  573.     long                             reservedH1;
  574.     long                             reservedH2;
  575.     IPMIOCompletionUPP                 ioCompletion;
  576.     OSErr                             ioResult;
  577.     long                             saveA5;
  578.     short                             reqCode;
  579.     FSSpec *                        hfsPath;
  580.     long                             filler;
  581.     IPMMsgRef                         newMsgRef;
  582.     long                             filler2;
  583.     Byte                             filler3;
  584.     Boolean                         filler4;
  585.     long                             reserved;
  586. };
  587. typedef struct IPMOpenHFSMsgPB IPMOpenHFSMsgPB;
  588.  
  589.  
  590. struct IPMOpenBlockAsMsgPB {
  591.     void *                            qLink;
  592.     long                             reservedH1;
  593.     long                             reservedH2;
  594.     IPMIOCompletionUPP                 ioCompletion;
  595.     OSErr                             ioResult;
  596.     long                             saveA5;
  597.     short                             reqCode;
  598.     IPMMsgRef                         msgRef;
  599.     unsigned long                     filler;
  600.     IPMMsgRef                         newMsgRef;
  601.     unsigned short                     filler2[7];
  602.     unsigned short                     blockIndex;
  603. };
  604. typedef struct IPMOpenBlockAsMsgPB IPMOpenBlockAsMsgPB;
  605.  
  606.  
  607. struct IPMCloseMsgPB {
  608.     void *                            qLink;
  609.     long                             reservedH1;
  610.     long                             reservedH2;
  611.     IPMIOCompletionUPP                 ioCompletion;
  612.     OSErr                             ioResult;
  613.     long                             saveA5;
  614.     short                             reqCode;
  615.     IPMMsgRef                         msgRef;
  616.     Boolean                         deleteMsg;
  617.     Boolean                         filler1;
  618. };
  619. typedef struct IPMCloseMsgPB IPMCloseMsgPB;
  620.  
  621.  
  622. struct IPMGetMsgInfoPB {
  623.     void *                            qLink;
  624.     long                             reservedH1;
  625.     long                             reservedH2;
  626.     IPMIOCompletionUPP                 ioCompletion;
  627.     OSErr                             ioResult;
  628.     long                             saveA5;
  629.     short                             reqCode;
  630.     IPMMsgRef                         msgRef;
  631.     IPMMsgInfo *                    info;
  632. };
  633. typedef struct IPMGetMsgInfoPB IPMGetMsgInfoPB;
  634.  
  635.  
  636. struct IPMReadHeaderPB {
  637.     void *                            qLink;
  638.     long                             reservedH1;
  639.     long                             reservedH2;
  640.     IPMIOCompletionUPP                 ioCompletion;
  641.     OSErr                             ioResult;
  642.     long                             saveA5;
  643.     short                             reqCode;
  644.     IPMMsgRef                         msgRef;
  645.     unsigned short                     fieldSelector;
  646.     long                             offset;
  647.     unsigned long                     count;
  648.     void *                            buffer;
  649.     unsigned long                     actualCount;
  650.     unsigned short                     filler;
  651.     unsigned long                     remaining;
  652. };
  653. typedef struct IPMReadHeaderPB IPMReadHeaderPB;
  654.  
  655.  
  656. struct IPMReadRecipientPB {
  657.     void *                            qLink;
  658.     long                             reservedH1;
  659.     long                             reservedH2;
  660.     IPMIOCompletionUPP                 ioCompletion;
  661.     OSErr                             ioResult;
  662.     long                             saveA5;
  663.     short                             reqCode;
  664.     IPMMsgRef                         msgRef;
  665.     unsigned short                     rcptIndex;
  666.     long                             offset;
  667.     unsigned long                     count;
  668.     void *                            buffer;
  669.     unsigned long                     actualCount;
  670.     short                             reserved;                    /* must be zero */
  671.     unsigned long                     remaining;
  672.     unsigned short                     originalIndex;
  673.     OCERecipientOffsetFlags         recipientOffsetFlags;
  674.     Boolean                         filler1;
  675. };
  676. typedef struct IPMReadRecipientPB IPMReadRecipientPB;
  677.  
  678.  
  679. /*
  680. replyQueue works like recipient. [can no longer read it via ReadHeader]
  681. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  682. currently none defined.
  683. */
  684. typedef IPMReadRecipientPB                 IPMReadReplyQueuePB;
  685. struct IPMGetBlkIndexPB {
  686.     void *                            qLink;
  687.     long                             reservedH1;
  688.     long                             reservedH2;
  689.     IPMIOCompletionUPP                 ioCompletion;
  690.     OSErr                             ioResult;
  691.     long                             saveA5;
  692.     short                             reqCode;
  693.     IPMMsgRef                         msgRef;
  694.     IPMBlockType                     blockType;
  695.     unsigned short                     index;
  696.     unsigned short                     startingFrom;
  697.     IPMBlockType                     actualBlockType;
  698.     unsigned short                     actualBlockIndex;
  699. };
  700. typedef struct IPMGetBlkIndexPB IPMGetBlkIndexPB;
  701.  
  702.  
  703. struct IPMReadMsgPB {
  704.     void *                            qLink;
  705.     long                             reservedH1;
  706.     long                             reservedH2;
  707.     IPMIOCompletionUPP                 ioCompletion;
  708.     OSErr                             ioResult;
  709.     long                             saveA5;
  710.     short                             reqCode;
  711.     IPMMsgRef                         msgRef;
  712.     IPMAccessMode                     mode;
  713.     long                             offset;
  714.     unsigned long                     count;
  715.     void *                            buffer;
  716.     unsigned long                     actualCount;
  717.     unsigned short                     blockIndex;
  718.     unsigned long                     remaining;
  719. };
  720. typedef struct IPMReadMsgPB IPMReadMsgPB;
  721.  
  722. struct IPMVerifySignaturePB {
  723.     void *                            qLink;
  724.     long                             reservedH1;
  725.     long                             reservedH2;
  726.     IPMIOCompletionUPP                 ioCompletion;
  727.     OSErr                             ioResult;
  728.     long                             saveA5;
  729.     short                             reqCode;
  730.     IPMMsgRef                         msgRef;
  731.     SIGContextPtr                     signatureContext;
  732. };
  733. typedef struct IPMVerifySignaturePB IPMVerifySignaturePB;
  734.  
  735. struct IPMNewMsgPB {
  736.     void *                            qLink;
  737.     long                             reservedH1;
  738.     long                             reservedH2;
  739.     IPMIOCompletionUPP                 ioCompletion;
  740.     OSErr                             ioResult;
  741.     long                             saveA5;
  742.     short                             reqCode;
  743.     unsigned long                     filler;
  744.     OCERecipient *                    recipient;
  745.     OCERecipient *                    replyQueue;
  746.     StringPtr                         procHint;
  747.     unsigned short                     filler2;
  748.     IPMMsgType *                    msgType;
  749.     unsigned long                     refCon;
  750.     IPMMsgRef                         newMsgRef;
  751.     unsigned short                     filler3;
  752.     long                             filler4;
  753.     AuthIdentity                     identity;
  754.     IPMSender *                        sender;
  755.     unsigned long                     internalUse;
  756.     unsigned long                     internalUse2;
  757. };
  758. typedef struct IPMNewMsgPB IPMNewMsgPB;
  759.  
  760. struct IPMNewHFSMsgPB {
  761.     void *                            qLink;
  762.     long                             reservedH1;
  763.     long                             reservedH2;
  764.     IPMIOCompletionUPP                 ioCompletion;
  765.     OSErr                             ioResult;
  766.     long                             saveA5;
  767.     short                             reqCode;
  768.     FSSpec *                        hfsPath;
  769.     OCERecipient *                    recipient;
  770.     OCERecipient *                    replyQueue;
  771.     StringPtr                         procHint;
  772.     unsigned short                     filler2;
  773.     IPMMsgType *                    msgType;
  774.     unsigned long                     refCon;
  775.     IPMMsgRef                         newMsgRef;
  776.     unsigned short                     filler3;
  777.     long                             filler4;
  778.     AuthIdentity                     identity;
  779.     IPMSender *                        sender;
  780.     unsigned long                     internalUse;
  781.     unsigned long                     internalUse2;
  782. };
  783. typedef struct IPMNewHFSMsgPB IPMNewHFSMsgPB;
  784.  
  785. struct IPMNestMsgPB {
  786.     void *                            qLink;
  787.     long                             reservedH1;
  788.     long                             reservedH2;
  789.     IPMIOCompletionUPP                 ioCompletion;
  790.     OSErr                             ioResult;
  791.     long                             saveA5;
  792.     short                             reqCode;
  793.     IPMMsgRef                         msgRef;
  794.     unsigned short                     filler[9];
  795.     unsigned long                     refCon;
  796.     IPMMsgRef                         msgToNest;
  797.     unsigned short                     filler2;
  798.     long                             startingOffset;
  799. };
  800. typedef struct IPMNestMsgPB IPMNestMsgPB;
  801.  
  802.  
  803. struct IPMNewNestedMsgBlockPB {
  804.     void *                            qLink;
  805.     long                             reservedH1;
  806.     long                             reservedH2;
  807.     IPMIOCompletionUPP                 ioCompletion;
  808.     OSErr                             ioResult;
  809.     long                             saveA5;
  810.     short                             reqCode;
  811.     IPMMsgRef                         msgRef;
  812.     OCERecipient *                    recipient;
  813.     OCERecipient *                    replyQueue;
  814.     StringPtr                         procHint;
  815.     unsigned short                     filler1;
  816.     IPMMsgType *                    msgType;
  817.     unsigned long                     refCon;
  818.     IPMMsgRef                         newMsgRef;
  819.     unsigned short                     filler2;
  820.     long                             startingOffset;
  821.     AuthIdentity                     identity;
  822.     IPMSender *                        sender;
  823.     unsigned long                     internalUse;
  824.     unsigned long                     internalUse2;
  825. };
  826. typedef struct IPMNewNestedMsgBlockPB IPMNewNestedMsgBlockPB;
  827.  
  828.  
  829. struct IPMEndMsgPB {
  830.     void *                            qLink;
  831.     long                             reservedH1;
  832.     long                             reservedH2;
  833.     IPMIOCompletionUPP                 ioCompletion;
  834.     OSErr                             ioResult;
  835.     long                             saveA5;
  836.     short                             reqCode;
  837.     IPMMsgRef                         msgRef;
  838.     IPMMsgID                         msgID;
  839.     RString *                        msgTitle;
  840.     IPMNotificationType             deliveryNotification;
  841.     IPMPriority                     priority;
  842.     Boolean                         cancel;
  843.     Byte                             padByte;
  844.     long                             reserved;
  845.     SIGSignaturePtr                 signature;
  846.     Size                             signatureSize;
  847.     SIGContextPtr                     signatureContext;
  848.                                                                 /* family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default */
  849.     OSType                             family;
  850. };
  851. typedef struct IPMEndMsgPB IPMEndMsgPB;
  852.  
  853.  
  854. struct IPMAddRecipientPB {
  855.     void *                            qLink;
  856.     long                             reservedH1;
  857.     long                             reservedH2;
  858.     IPMIOCompletionUPP                 ioCompletion;
  859.     OSErr                             ioResult;
  860.     long                             saveA5;
  861.     short                             reqCode;
  862.     IPMMsgRef                         msgRef;
  863.     OCERecipient *                    recipient;
  864.     long                             reserved;
  865. };
  866. typedef struct IPMAddRecipientPB IPMAddRecipientPB;
  867.  
  868.  
  869. struct IPMAddReplyQueuePB {
  870.     void *                            qLink;
  871.     long                             reservedH1;
  872.     long                             reservedH2;
  873.     IPMIOCompletionUPP                 ioCompletion;
  874.     OSErr                             ioResult;
  875.     long                             saveA5;
  876.     short                             reqCode;
  877.     IPMMsgRef                         msgRef;
  878.     long                             filler;
  879.     OCERecipient *                    replyQueue;
  880. };
  881. typedef struct IPMAddReplyQueuePB IPMAddReplyQueuePB;
  882.  
  883.  
  884. struct IPMNewBlockPB {
  885.     void *                            qLink;
  886.     long                             reservedH1;
  887.     long                             reservedH2;
  888.     IPMIOCompletionUPP                 ioCompletion;
  889.     OSErr                             ioResult;
  890.     long                             saveA5;
  891.     short                             reqCode;
  892.     IPMMsgRef                         msgRef;
  893.     IPMBlockType                     blockType;
  894.     unsigned short                     filler[5];
  895.     unsigned long                     refCon;
  896.     unsigned short                     filler2[3];
  897.     long                             startingOffset;
  898. };
  899. typedef struct IPMNewBlockPB IPMNewBlockPB;
  900.  
  901.  
  902. struct IPMWriteMsgPB {
  903.     void *                            qLink;
  904.     long                             reservedH1;
  905.     long                             reservedH2;
  906.     IPMIOCompletionUPP                 ioCompletion;
  907.     OSErr                             ioResult;
  908.     long                             saveA5;
  909.     short                             reqCode;
  910.     IPMMsgRef                         msgRef;
  911.     IPMAccessMode                     mode;
  912.     long                             offset;
  913.     unsigned long                     count;
  914.     void *                            buffer;
  915.     unsigned long                     actualCount;
  916.     Boolean                         currentBlock;
  917.     Boolean                         filler1;
  918. };
  919. typedef struct IPMWriteMsgPB IPMWriteMsgPB;
  920.  
  921.  
  922.  
  923. union IPMParamBlock {
  924.     struct {
  925.         void *                            qLink;
  926.         long                             reservedH1;
  927.         long                             reservedH2;
  928.         IPMIOCompletionUPP                 ioCompletion;
  929.         OSErr                             ioResult;
  930.         long                             saveA5;
  931.         short                             reqCode;
  932.     }                                 header;
  933.     IPMOpenContextPB                 openContextPB;
  934.     IPMCloseContextPB                 closeContextPB;
  935.     IPMCreateQueuePB                 createQueuePB;
  936.     IPMDeleteQueuePB                 deleteQueuePB;
  937.     IPMOpenQueuePB                     openQueuePB;
  938.     IPMCloseQueuePB                 closeQueuePB;
  939.     IPMEnumerateQueuePB             enumerateQueuePB;
  940.     IPMChangeQueueFilterPB             changeQueueFilterPB;
  941.     IPMDeleteMsgRangePB             deleteMsgRangePB;
  942.     IPMOpenMsgPB                     openMsgPB;
  943.     IPMOpenHFSMsgPB                 openHFSMsgPB;
  944.     IPMOpenBlockAsMsgPB             openBlockAsMsgPB;
  945.     IPMCloseMsgPB                     closeMsgPB;
  946.     IPMGetMsgInfoPB                 getMsgInfoPB;
  947.     IPMReadHeaderPB                 readHeaderPB;
  948.     IPMReadRecipientPB                 readRecipientPB;
  949.     IPMReadReplyQueuePB             readReplyQueuePB;
  950.     IPMGetBlkIndexPB                 getBlkIndexPB;
  951.     IPMReadMsgPB                     readMsgPB;
  952.     IPMVerifySignaturePB             verifySignaturePB;
  953.     IPMNewMsgPB                     newMsgPB;
  954.     IPMNewHFSMsgPB                     newHFSMsgPB;
  955.     IPMNestMsgPB                     nestMsgPB;
  956.     IPMNewNestedMsgBlockPB             newNestedMsgBlockPB;
  957.     IPMEndMsgPB                     endMsgPB;
  958.     IPMAddRecipientPB                 addRecipientPB;
  959.     IPMAddReplyQueuePB                 addReplyQueuePB;
  960.     IPMNewBlockPB                     newBlockPB;
  961.     IPMWriteMsgPB                     writeMsgPB;
  962. };
  963.  
  964. enum { uppIPMIOCompletionProcInfo = 0x00009802 };                 /* register no_return_value Func(4_bytes:A0) */
  965. #if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  966.     #pragma parameter CallIPMIOCompletionProc(__A1, __A0)
  967.     void CallIPMIOCompletionProc(IPMIOCompletionUPP routine, IPMParamBlockPtr paramBlock) = 0x4E91;
  968. #else
  969.     #define CallIPMIOCompletionProc(userRoutine, paramBlock)     CALL_ONE_PARAMETER_UPP((userRoutine), uppIPMIOCompletionProcInfo, (paramBlock))
  970. #endif
  971. #define NewIPMIOCompletionProc(userRoutine)                     (IPMIOCompletionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPMIOCompletionProcInfo, GetCurrentArchitecture())
  972. EXTERN_API( OSErr )
  973. IPMOpenContext                    (IPMParamBlockPtr         paramBlock,
  974.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0400, 0xAA5E);
  975.  
  976. EXTERN_API( OSErr )
  977. IPMCloseContext                    (IPMParamBlockPtr         paramBlock,
  978.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0401, 0xAA5E);
  979.  
  980. EXTERN_API( OSErr )
  981. IPMNewMsg                        (IPMParamBlockPtr         paramBlock,
  982.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0402, 0xAA5E);
  983.  
  984. EXTERN_API( OSErr )
  985. IPMNewBlock                        (IPMParamBlockPtr         paramBlock,
  986.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0404, 0xAA5E);
  987.  
  988. EXTERN_API( OSErr )
  989. IPMNewNestedMsgBlock            (IPMParamBlockPtr         paramBlock,
  990.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0405, 0xAA5E);
  991.  
  992. EXTERN_API( OSErr )
  993. IPMNestMsg                        (IPMParamBlockPtr         paramBlock,
  994.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0406, 0xAA5E);
  995.  
  996. EXTERN_API( OSErr )
  997. IPMWriteMsg                        (IPMParamBlockPtr         paramBlock,
  998.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0407, 0xAA5E);
  999.  
  1000. EXTERN_API( OSErr )
  1001. IPMEndMsg                        (IPMParamBlockPtr         paramBlock,
  1002.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0408, 0xAA5E);
  1003.  
  1004. EXTERN_API( OSErr )
  1005. IPMOpenQueue                    (IPMParamBlockPtr         paramBlock,
  1006.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0409, 0xAA5E);
  1007.  
  1008. EXTERN_API( OSErr )
  1009. IPMCloseQueue                    (IPMParamBlockPtr         paramBlock,
  1010.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040A, 0xAA5E);
  1011.  
  1012. /* Always synchronous */
  1013. EXTERN_API( OSErr )
  1014. IPMVerifySignature                (IPMParamBlockPtr         paramBlock)                            FIVEWORDINLINE(0x7000, 0x1F00, 0x3F3C, 0x0422, 0xAA5E);
  1015.  
  1016. EXTERN_API( OSErr )
  1017. IPMOpenMsg                        (IPMParamBlockPtr         paramBlock,
  1018.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040B, 0xAA5E);
  1019.  
  1020. EXTERN_API( OSErr )
  1021. IPMCloseMsg                        (IPMParamBlockPtr         paramBlock,
  1022.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040C, 0xAA5E);
  1023.  
  1024. EXTERN_API( OSErr )
  1025. IPMReadMsg                        (IPMParamBlockPtr         paramBlock,
  1026.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040D, 0xAA5E);
  1027.  
  1028. EXTERN_API( OSErr )
  1029. IPMReadHeader                    (IPMParamBlockPtr         paramBlock,
  1030.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040E, 0xAA5E);
  1031.  
  1032. EXTERN_API( OSErr )
  1033. IPMOpenBlockAsMsg                (IPMParamBlockPtr         paramBlock,
  1034.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x040F, 0xAA5E);
  1035.  
  1036. EXTERN_API( OSErr )
  1037. IPMNewHFSMsg                    (IPMParamBlockPtr         paramBlock,
  1038.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x041E, 0xAA5E);
  1039.  
  1040. EXTERN_API( OSErr )
  1041. IPMReadRecipient                (IPMParamBlockPtr         paramBlock,
  1042.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0410, 0xAA5E);
  1043.  
  1044. EXTERN_API( OSErr )
  1045. IPMReadReplyQueue                (IPMParamBlockPtr         paramBlock,
  1046.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0421, 0xAA5E);
  1047.  
  1048. EXTERN_API( OSErr )
  1049. IPMCreateQueue                    (IPMParamBlockPtr         paramBlock,
  1050.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0411, 0xAA5E);
  1051.  
  1052. EXTERN_API( OSErr )
  1053. IPMDeleteQueue                    (IPMParamBlockPtr         paramBlock,
  1054.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0412, 0xAA5E);
  1055.  
  1056. EXTERN_API( OSErr )
  1057. IPMEnumerateQueue                (IPMParamBlockPtr         paramBlock,
  1058.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0413, 0xAA5E);
  1059.  
  1060. EXTERN_API( OSErr )
  1061. IPMChangeQueueFilter            (IPMParamBlockPtr         paramBlock,
  1062.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0414, 0xAA5E);
  1063.  
  1064. EXTERN_API( OSErr )
  1065. IPMDeleteMsgRange                (IPMParamBlockPtr         paramBlock,
  1066.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0415, 0xAA5E);
  1067.  
  1068. EXTERN_API( OSErr )
  1069. IPMAddRecipient                    (IPMParamBlockPtr         paramBlock,
  1070.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0403, 0xAA5E);
  1071.  
  1072. EXTERN_API( OSErr )
  1073. IPMAddReplyQueue                (IPMParamBlockPtr         paramBlock,
  1074.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x041D, 0xAA5E);
  1075.  
  1076. EXTERN_API( OSErr )
  1077. IPMOpenHFSMsg                    (IPMParamBlockPtr         paramBlock,
  1078.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0417, 0xAA5E);
  1079.  
  1080. EXTERN_API( OSErr )
  1081. IPMGetBlkIndex                    (IPMParamBlockPtr         paramBlock,
  1082.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0418, 0xAA5E);
  1083.  
  1084. EXTERN_API( OSErr )
  1085. IPMGetMsgInfo                    (IPMParamBlockPtr         paramBlock,
  1086.                                  Boolean                 async)                                THREEWORDINLINE(0x3F3C, 0x0419, 0xAA5E);
  1087.  
  1088.  
  1089.  
  1090.  
  1091. #if PRAGMA_STRUCT_ALIGN
  1092.     #pragma options align=reset
  1093. #elif PRAGMA_STRUCT_PACKPUSH
  1094.     #pragma pack(pop)
  1095. #elif PRAGMA_STRUCT_PACK
  1096.     #pragma pack()
  1097. #endif
  1098.  
  1099. #ifdef PRAGMA_IMPORT_OFF
  1100. #pragma import off
  1101. #elif PRAGMA_IMPORT
  1102. #pragma import reset
  1103. #endif
  1104.  
  1105. #ifdef __cplusplus
  1106. }
  1107. #endif
  1108.  
  1109. #endif /* __OCEMESSAGING__ */
  1110.  
  1111.